import java.util.*;

//子集(DFS)
public class TestDemo9B {
    public List<List<Integer>> subsets(int[] nums){
        ArrayList<List<Integer>>result=new ArrayList<>();
        backtracking(nums,result,0,new ArrayList<>());
        return result;
    }

    private void backtracking(int[] nums, ArrayList<List<Integer>> result, int index, ArrayList<Integer> list) {
        result.add(new ArrayList<>(list));//每次递归都有满足的值
        if(index== nums.length){//遇到最后一个元素(3)就直接返回
            return ;
        }
        for(int i=index;i< nums.length;i++){
            list.add(nums[i]);
            backtracking(nums,result,i+1,list);
            list.remove(list.size()-1);//递归完一次之后需要把这一次递归的最后一个值删掉
            //才能往后继续遍历
        }
    }

    public static void main2(String[]args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int []nums=new int [n];
        for(int i=0;i<n;i++){
            nums[i]=sc.nextInt();
        }
        Arrays.sort(nums);
        System.out.println(count1(nums,n,0,0,1));
    }
    public static int count1(int []a,int n,int post,int sum,int milit){
        int count=0;
        for(int i=post;i<n;i++){
            sum+=a[i];
            milit*=a[i];
            if(sum>milit){
                count=count+1+count1(a,n,i+1,sum,milit);

            }
            else if(a[i]==1){
                count=count+count1(a,n,i+1,sum,milit);
            }
            else{
                break;
            }
            sum=sum-a[i];
            milit=milit/a[i];
            while(i<n-1&&a[i]==a[i+1]){
                i++;
            }
        }
        return count;
    }

    public static void main1(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int []nums=new int[n];
        for(int i=0;i<n;i++){
            nums[i]=sc.nextInt();
        }
        Arrays.sort(nums);//排序是为了下面的break,遇到不符合的,那么该下标之后的所有数都不符合
        //就直接break不用计算后面的 数,减少递归次数,更高效
        System.out.println(count(nums,n,0,0,1));
    }
    public static int count=0;
    public static int count(int[]a,int n,int index,int sum,int mulit){
        for(int i=index;i<n;i++){
            sum+=a[i];
            mulit*=a[i];
            if(sum>mulit){
                count++;
                count(a,n,i+1,sum,mulit);
                //当a[i]是在首位是1的时候,sum和mulit相等,但不能说明后面的数不符合sum>mulit
                //需要继续递归判断后面的数
            }else if(a[i]==1){
                count(a,n,i+1,sum,mulit);
            }else{//当前数不符合,说明后面大的数一定不符合,直接跳过本次循环
                break;
            }
            sum-=a[i];
            mulit/=a[i];
            //当两个数相同,属于同一情况,不计算,跳过
            while(i<n-1&&a[i]==a[i+1]){
                i++;
            }
        }
        return count;
    }

    public static int findMinimum(int n, int[] left, int[] right) {
        // write code here
        int leftMin=Integer.MAX_VALUE;
        int rightMin=Integer.MAX_VALUE;
        int leftSum=0;
        int rightSum=0;
        int sum=0;
        for(int i=0;i<n;i++){
            //左手套和右手套至少一个下标为0的情况
            if(left[i]*right[i]==0){
                sum+=left[i]+right[i];
            }else{
                leftSum+=left[i];
                rightSum+=right[i];
                if(leftMin>left[i]){
                    leftMin=left[i];
                }
                if(rightMin>right[i]){
                    rightMin=right[i];
                }
            }
        }
        return sum+Math.min(leftSum-leftMin+1,rightSum-rightMin+1)+1;
    }

    public static void main4(String[] args) {
        int[] left={0,7,1,6};
        int []right={1,5,0,6};
        int count=findMinimum(4,left,right);
        System.out.println(count);
    }
    public static void main5(String[]args){
        Scanner sc=new Scanner(System.in);
        String str=sc.nextLine();
        String[] pp=str.split("-");//数组分段(以-分成数组下标-两个手牌)
        //题目规定好了,该手牌已经排好序,我们需要比较第一个下标大小即可
        //这是就需要对2个手牌转化成数组(以空格为分隔)
        String []p1=pp[0].split(" ");
        String[]p2=pp[1].split(" ");
        //定义一个完整的手牌,手牌大小从左到右排好序了,比较大小的时候根据s字符串的下标
        //位置比较大小(注意:需要把10改写1),目的是 为了更好了访问首字符,到时候只截取(substring)字符串中的一个字符
        String s="34567891JQKA2";
        //如果有对王就直接打印
        if(pp[0].equals("joker JOKER")||pp[1].equals("joker JOKER")){
            System.out.println("joker JOKER");
            //手牌相同的情况,就直接比较首下标的大小即可
        }else if(p1.length==p2.length){
            if(s.indexOf(p1[0].substring(0,1))>s.indexOf(p2[0].substring(0,1))){
                System.out.println(pp[0]);
            }else{
                System.out.println(pp[1]);
            }
        }//如果有炸弹直接返回炸弹,不考虑比较炸弹的比较大小,前面已经比较过了
        else if(p1.length==4){
            System.out.println(pp[0]);
        }else if(p2.length==4){
            System.out.println(pp[1]);
        }else{
            System.out.println("ERROR");
        }
    }

    //岛屿数量(dfs)
    public int numIslands(char[][] grid) {
        if(grid==null||grid.length==0){
            return 0;
        }
        int result=0;
        int row=grid.length;
        int col=grid[0].length;
        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                if(grid[i][j]=='1'){
                    result++;
                    dfs(grid,i,j,row,col);
                }
            }
        }
        return result;
    }
    public void dfs(char[][]grid,int x,int y,int row,int col){
        if(x<0||y<0||x>=row||y>=col||grid[x][y]=='0'){
            return ;
        }
        grid[x][y]='0';
        dfs(grid,x+1,y,row,col);
        dfs(grid,x-1,y,row,col);
        dfs(grid,x,y+1,row,col);
        dfs(grid,x,y-1,row,col);
    }
    //岛屿数量(BFS-队列)--基本思想与DFS一样
    public int numIslands1(char[][] grid) {
        if(grid==null||grid.length==0){
            return 0;
        }
        int result=0;
        int row=grid.length;
        int col=grid[0].length;
        Queue<int[]> queue=new LinkedList<>();
        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                //每次发现岛屿就++一次,然后再将该岛屿周围的岛屿置为0,只到发现了
                //下一个岛屿就++
                if(grid[i][j]=='1'){
                    result++;
                    //将二维数组的下标值转为一维数组下标值存放到队列中
                    queue.add(new int[]{i,j});
                    grid[i][j]='0';
                    while(queue.size()>0){
                        int[] cur=queue.poll();
                        int x=cur[0];//横坐标
                        int y=cur[1];//纵坐标
                        if(x-1>=0&&grid[x-1][y]=='1'){
                            grid[x-1][y]='0';
                            queue.add(new int[]{x-1,y});
                        }
                        if(y-1>=0&&grid[x][y-1]=='1'){
                            grid[x][y-1]='0';
                            queue.add(new  int[]{x,y-1});
                        }
                        if(x+1<row&&grid[x+1][y]=='1'){
                            grid[x+1][y]='0';
                            queue.add(new int[]{x+1,y});
                        }
                        if(y+1<col&&grid[x][y+1]=='1'){
                            grid[x][y+1]='0';
                            queue.add(new int[]{x,y+1});
                        }
                    }
                }
            }
        }
        return result;
    }

    public static void main(String[]args){
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            int year=sc.nextInt();
            int mouth=sc.nextInt();
            int day=sc.nextInt();
            int []a={31,28,31,30,31,30,31,31,30,31,30,31};
            if(mouth==1){
                System.out.println(day);
                break;
            }
            if((year%4==0||year%400==0)&&year%100!=0){
                day+=1;
            }
            for(int i=0;i<mouth-1;i++){
                day+=a[i];
            }
            System.out.println(day);
        }
    }
}

